/**
 * Copyright 2025 Google LLC
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

import type Anthropic from '@anthropic-ai/sdk';
import type {
  Message,
  MessageCreateParams,
  MessageParam,
  MessageStreamEvent,
} from '@anthropic-ai/sdk/resources/messages.mjs';
import * as assert from 'assert';
import type {
  GenerateRequest,
  GenerateResponseData,
  MessageData,
  Part,
  Role,
} from 'genkit';
import type { CandidateData, ToolDefinition } from 'genkit/model';
import { describe, it, mock } from 'node:test';

import { claudeModel, claudeRunner } from '../src/models.js';
import { Runner } from '../src/runner/stable.js';
import { AnthropicConfigSchema } from '../src/types.js';
import {
  createMockAnthropicClient,
  mockContentBlockStart,
  mockTextChunk,
} from './mocks/anthropic-client.js';

// Test helper: Create a Runner instance for testing converter methods
// Type interface to access protected methods in tests
type RunnerProtectedMethods = {
  toAnthropicRole: (
    role: Role,
    toolMessageType?: 'tool_use' | 'tool_result'
  ) => 'user' | 'assistant';
  toAnthropicToolResponseContent: (part: Part) => any;
  toAnthropicMessageContent: (part: Part) => any;
  toAnthropicMessages: (messages: MessageData[]) => {
    system?: string;
    messages: any[];
  };
  toAnthropicTool: (tool: ToolDefinition) => any;
  toAnthropicRequestBody: (
    modelName: string,
    request: GenerateRequest<typeof AnthropicConfigSchema>,
    cacheSystemPrompt?: boolean
  ) => any;
  toAnthropicStreamingRequestBody: (
    modelName: string,
    request: GenerateRequest<typeof AnthropicConfigSchema>,
    cacheSystemPrompt?: boolean
  ) => any;
  fromAnthropicContentBlockChunk: (
    event: MessageStreamEvent
  ) => Part | undefined;
  fromAnthropicStopReason: (reason: Message['stop_reason']) => any;
  fromAnthropicResponse: (message: Message) => GenerateResponseData;
};

const mockClient = createMockAnthropicClient();
const testRunner = new Runner({
  name: 'test-model',
  client: mockClient,
}) as Runner & RunnerProtectedMethods;

const createUsage = (
  overrides: Partial<Message['usage']> = {}
): Message['usage'] => ({
  cache_creation: null,
  cache_creation_input_tokens: 0,
  cache_read_input_tokens: 0,
  input_tokens: 0,
  output_tokens: 0,
  server_tool_use: null,
  service_tier: null,
  ...overrides,
});

describe('toAnthropicRole', () => {
  const testCases: {
    genkitRole: Role;
    toolMessageType?: 'tool_use' | 'tool_result';
    expectedAnthropicRole: MessageParam['role'];
  }[] = [
    {
      genkitRole: 'user',
      expectedAnthropicRole: 'user',
    },
    {
      genkitRole: 'model',
      expectedAnthropicRole: 'assistant',
    },
    {
      genkitRole: 'tool',
      toolMessageType: 'tool_use',
      expectedAnthropicRole: 'assistant',
    },
    {
      genkitRole: 'tool',
      toolMessageType: 'tool_result',
      expectedAnthropicRole: 'user',
    },
  ];

  for (const test of testCases) {
    it(`should map Genkit "${test.genkitRole}" role to Anthropic "${test.expectedAnthropicRole}" role${
      test.toolMessageType
        ? ` when toolMessageType is "${test.toolMessageType}"`
        : ''
    }`, () => {
      const actualOutput = testRunner.toAnthropicRole(
        test.genkitRole,
        test.toolMessageType
      );
      assert.strictEqual(actualOutput, test.expectedAnthropicRole);
    });
  }

  it('should throw an error for unknown roles', () => {
    assert.throws(
      () => testRunner.toAnthropicRole('unknown' as Role),
      /Unsupported genkit role: unknown/
    );
  });
});

describe('toAnthropicToolResponseContent', () => {
  it('should not throw for parts without toolResponse', () => {
    // toAnthropicToolResponseContent expects part.toolResponse to exist
    // but will just return stringified undefined/empty object if not
    const part: Part = { data: 'hi' } as Part;
    const result = testRunner.toAnthropicToolResponseContent(part);
    assert.ok(result);
    assert.strictEqual(result.type, 'text');
  });
});

describe('toAnthropicMessageContent', () => {
  it('should throw if a media part contains invalid media', () => {
    assert.throws(
      () =>
        testRunner.toAnthropicMessageContent({
          media: {
            url: '',
          },
        }),
      /Media url is required but was not provided/
    );
  });

  it('should throw if the provided part is invalid', () => {
    assert.throws(
      () => testRunner.toAnthropicMessageContent({ fake: 'part' } as Part),
      /Unsupported genkit part fields encountered for current message role: {"fake":"part"}/
    );
  });

  it('should treat remote URLs without explicit content type as image URLs', () => {
    const result = testRunner.toAnthropicMessageContent({
      media: {
        url: 'https://example.com/image.png',
      },
    });

    assert.deepStrictEqual(result, {
      type: 'image',
      source: {
        type: 'url',
        url: 'https://example.com/image.png',
      },
    });
  });

  it('should handle PDF with base64 data URL correctly', () => {
    const result = testRunner.toAnthropicMessageContent({
      media: {
        url: 'data:application/pdf;base64,JVBERi0xLjQKJ',
        contentType: 'application/pdf',
      },
    });

    assert.deepStrictEqual(result, {
      type: 'document',
      source: {
        type: 'base64',
        media_type: 'application/pdf',
        data: 'JVBERi0xLjQKJ',
      },
    });
  });

  it('should handle PDF with HTTP/HTTPS URL correctly', () => {
    const result = testRunner.toAnthropicMessageContent({
      media: {
        url: 'https://example.com/document.pdf',
        contentType: 'application/pdf',
      },
    });

    assert.deepStrictEqual(result, {
      type: 'document',
      source: {
        type: 'url',
        url: 'https://example.com/document.pdf',
      },
    });
  });
});

describe('toAnthropicMessages', () => {
  const testCases: {
    should: string;
    inputMessages: MessageData[];
    expectedOutput: {
      messages: MessageParam[];
      system?: string;
    };
  }[] = [
    {
      should: 'should transform tool request content correctly',
      inputMessages: [
        {
          role: 'model',
          content: [
            {
              toolRequest: {
                ref: 'toolu_01A09q90qw90lq917835lq9',
                name: 'tellAFunnyJoke',
                input: { topic: 'bob' },
              },
            },
          ],
        },
      ],
      expectedOutput: {
        messages: [
          {
            role: 'assistant',
            content: [
              {
                type: 'tool_use',
                id: 'toolu_01A09q90qw90lq917835lq9',
                name: 'tellAFunnyJoke',
                input: { topic: 'bob' },
              },
            ],
          },
        ],
        system: undefined,
      },
    },
    {
      should: 'should transform tool response text content correctly',
      inputMessages: [
        {
          role: 'tool',
          content: [
            {
              toolResponse: {
                ref: 'call_SVDpFV2l2fW88QRFtv85FWwM',
                name: 'tellAFunnyJoke',
                output: 'Why did the bob cross the road?',
              },
            },
          ],
        },
      ],
      expectedOutput: {
        messages: [
          {
            role: 'user',
            content: [
              {
                type: 'tool_result',
                tool_use_id: 'call_SVDpFV2l2fW88QRFtv85FWwM',
                content: [
                  {
                    type: 'text',
                    text: 'Why did the bob cross the road?',
                  },
                ],
              },
            ],
          },
        ],
        system: undefined,
      },
    },
    {
      should: 'should transform tool response media content correctly',
      inputMessages: [
        {
          role: 'tool',
          content: [
            {
              toolResponse: {
                ref: 'call_SVDpFV2l2fW88QRFtv85FWwM',
                name: 'tellAFunnyJoke',
                output: {
                  url: '',
                  contentType: 'image/gif',
                },
              },
            },
          ],
        },
      ],
      expectedOutput: {
        messages: [
          {
            role: 'user',
            content: [
              {
                type: 'tool_result',
                tool_use_id: 'call_SVDpFV2l2fW88QRFtv85FWwM',
                content: [
                  {
                    type: 'image',
                    source: {
                      type: 'base64',
                      data: 'R0lGODlhAQABAAAAACw=',
                      media_type: 'image/gif',
                    },
                  },
                ],
              },
            ],
          },
        ],
        system: undefined,
      },
    },
    {
      should:
        'should transform tool response base64 image url content correctly',
      inputMessages: [
        {
          role: 'tool',
          content: [
            {
              toolResponse: {
                ref: 'call_SVDpFV2l2fW88QRFtv85FWwM',
                name: 'tellAFunnyJoke',
                output: '',
              },
            },
          ],
        },
      ],
      expectedOutput: {
        messages: [
          {
            role: 'user',
            content: [
              {
                type: 'tool_result',
                tool_use_id: 'call_SVDpFV2l2fW88QRFtv85FWwM',
                content: [
                  {
                    type: 'image',
                    source: {
                      type: 'base64',
                      data: 'R0lGODlhAQABAAAAACw=',
                      media_type: 'image/gif',
                    },
                  },
                ],
              },
            ],
          },
        ],
        system: undefined,
      },
    },
    {
      should: 'should transform text content correctly',
      inputMessages: [
        { role: 'user', content: [{ text: 'hi' }] },
        { role: 'model', content: [{ text: 'how can I help you?' }] },
        { role: 'user', content: [{ text: 'I am testing' }] },
      ],
      expectedOutput: {
        messages: [
          {
            content: [
              {
                text: 'hi',
                type: 'text',
                citations: null,
              },
            ],
            role: 'user',
          },
          {
            content: [
              {
                text: 'how can I help you?',
                type: 'text',
                citations: null,
              },
            ],
            role: 'assistant',
          },
          {
            content: [
              {
                text: 'I am testing',
                type: 'text',
                citations: null,
              },
            ],
            role: 'user',
          },
        ],
        system: undefined,
      },
    },
    {
      should: 'should transform initial system prompt correctly',
      inputMessages: [
        { role: 'system', content: [{ text: 'You are an helpful assistant' }] },
        { role: 'user', content: [{ text: 'hi' }] },
      ],
      expectedOutput: {
        messages: [
          {
            content: [
              {
                text: 'hi',
                type: 'text',
                citations: null,
              },
            ],
            role: 'user',
          },
        ],
        system: 'You are an helpful assistant',
      },
    },
    {
      should: 'should transform multi-modal (text + media) content correctly',
      inputMessages: [
        {
          role: 'user',
          content: [
            { text: 'describe the following image:' },
            {
              media: {
                url: '',
                contentType: 'image/gif',
              },
            },
          ],
        },
      ],
      expectedOutput: {
        messages: [
          {
            content: [
              {
                text: 'describe the following image:',
                type: 'text',
                citations: null,
              },
              {
                source: {
                  type: 'base64',
                  data: 'R0lGODlhAQABAAAAACw=',
                  media_type: 'image/gif',
                },
                type: 'image',
              },
            ],
            role: 'user',
          },
        ],
        system: undefined,
      },
    },
    {
      should: 'should transform PDF with base64 data URL correctly',
      inputMessages: [
        {
          role: 'user',
          content: [
            {
              media: {
                url: 'data:application/pdf;base64,JVBERi0xLjQKJ',
                contentType: 'application/pdf',
              },
            },
          ],
        },
      ],
      expectedOutput: {
        messages: [
          {
            content: [
              {
                type: 'document',
                source: {
                  type: 'base64',
                  media_type: 'application/pdf',
                  data: 'JVBERi0xLjQKJ',
                },
              },
            ],
            role: 'user',
          },
        ],
        system: undefined,
      },
    },
    {
      should: 'should transform PDF with HTTP/HTTPS URL correctly',
      inputMessages: [
        {
          role: 'user',
          content: [
            {
              media: {
                url: 'https://example.com/document.pdf',
                contentType: 'application/pdf',
              },
            },
          ],
        },
      ],
      expectedOutput: {
        messages: [
          {
            content: [
              {
                type: 'document',
                source: {
                  type: 'url',
                  url: 'https://example.com/document.pdf',
                },
              },
            ],
            role: 'user',
          },
        ],
        system: undefined,
      },
    },
    {
      should: 'should transform PDF alongside text and images correctly',
      inputMessages: [
        {
          role: 'user',
          content: [
            { text: 'Analyze this PDF and image:' },
            {
              media: {
                url: 'data:application/pdf;base64,JVBERi0xLjQKJ',
                contentType: 'application/pdf',
              },
            },
            {
              media: {
                url: '',
                contentType: 'image/png',
              },
            },
          ],
        },
      ],
      expectedOutput: {
        messages: [
          {
            content: [
              {
                text: 'Analyze this PDF and image:',
                type: 'text',
                citations: null,
              },
              {
                type: 'document',
                source: {
                  type: 'base64',
                  media_type: 'application/pdf',
                  data: 'JVBERi0xLjQKJ',
                },
              },
              {
                source: {
                  type: 'base64',
                  data: 'R0lGODlhAQABAAAAACw=',
                  media_type: 'image/png',
                },
                type: 'image',
              },
            ],
            role: 'user',
          },
        ],
        system: undefined,
      },
    },
  ];

  for (const test of testCases) {
    it(test.should, () => {
      const actualOutput = testRunner.toAnthropicMessages(test.inputMessages);
      assert.deepStrictEqual(actualOutput, test.expectedOutput);
    });
  }
});

describe('toAnthropicTool', () => {
  it('should transform Genkit tool definition to an Anthropic tool', () => {
    const tool: ToolDefinition = {
      name: 'tellAJoke',
      description: 'Tell a joke',
      inputSchema: {
        type: 'object',
        properties: {
          topic: { type: 'string' },
        },
        required: ['topic'],
      },
    };
    const actualOutput = testRunner.toAnthropicTool(tool);
    assert.deepStrictEqual(actualOutput, {
      name: 'tellAJoke',
      description: 'Tell a joke',
      input_schema: {
        type: 'object',
        properties: {
          topic: { type: 'string' },
        },
        required: ['topic'],
      },
    });
  });
});

describe('fromAnthropicContentBlockChunk', () => {
  const testCases: {
    should: string;
    event: MessageStreamEvent;
    expectedOutput: Part | undefined;
  }[] = [
    {
      should: 'should return text part from content_block_start event',
      event: {
        index: 0,
        type: 'content_block_start',
        content_block: {
          type: 'text',
          text: 'Hello, World!',
          citations: null,
        },
      },
      expectedOutput: { text: 'Hello, World!' },
    },
    {
      should:
        'should return thinking part from content_block_start thinking event',
      event: {
        index: 0,
        type: 'content_block_start',
        content_block: {
          type: 'thinking',
          thinking: 'Let me reason through this.',
          signature: 'sig_123',
        },
      },
      expectedOutput: {
        reasoning: 'Let me reason through this.',
        custom: { anthropicThinking: { signature: 'sig_123' } },
      },
    },
    {
      should:
        'should return redacted thinking part from content_block_start event',
      event: {
        index: 0,
        type: 'content_block_start',
        content_block: {
          type: 'redacted_thinking',
          data: 'encrypted-data',
        },
      },
      expectedOutput: { custom: { redactedThinking: 'encrypted-data' } },
    },
    {
      should: 'should return text delta part from content_block_delta event',
      event: {
        index: 0,
        type: 'content_block_delta',
        delta: {
          type: 'text_delta',
          text: 'Hello, World!',
        },
      },
      expectedOutput: { text: 'Hello, World!' },
    },
    {
      should: 'should return thinking delta part as text content',
      event: {
        index: 0,
        type: 'content_block_delta',
        delta: {
          type: 'thinking_delta',
          thinking: 'Step by step...',
        },
      },
      expectedOutput: { reasoning: 'Step by step...' },
    },
    {
      should: 'should return tool use requests',
      event: {
        index: 0,
        type: 'content_block_start',
        content_block: {
          type: 'tool_use',
          id: 'abc123',
          name: 'tellAJoke',
          input: { topic: 'dogs' },
        },
      },
      expectedOutput: {
        toolRequest: {
          name: 'tellAJoke',
          input: { topic: 'dogs' },
          ref: 'abc123',
        },
      },
    },
    {
      should: 'should return undefined for any other event',
      event: {
        type: 'message_stop',
      },
      expectedOutput: undefined,
    },
  ];

  for (const test of testCases) {
    it(test.should, () => {
      const actualOutput = testRunner.fromAnthropicContentBlockChunk(
        test.event
      );
      assert.deepStrictEqual(actualOutput, test.expectedOutput);
    });
  }

  it('should throw for unsupported tool input streaming deltas', () => {
    assert.throws(
      () =>
        testRunner.fromAnthropicContentBlockChunk({
          index: 0,
          type: 'content_block_delta',
          delta: {
            type: 'input_json_delta',
            partial_json: '{"foo":',
          },
        } as MessageStreamEvent),
      /Anthropic streaming tool input \(input_json_delta\) is not yet supported/
    );
  });
});

describe('fromAnthropicStopReason', () => {
  const testCases: {
    inputStopReason: Message['stop_reason'];
    expectedFinishReason: CandidateData['finishReason'];
  }[] = [
    {
      inputStopReason: 'max_tokens',
      expectedFinishReason: 'length',
    },
    {
      inputStopReason: 'end_turn',
      expectedFinishReason: 'stop',
    },
    {
      inputStopReason: 'stop_sequence',
      expectedFinishReason: 'stop',
    },
    {
      inputStopReason: 'tool_use',
      expectedFinishReason: 'stop',
    },
    {
      inputStopReason: null,
      expectedFinishReason: 'unknown',
    },
    {
      inputStopReason: 'unknown' as any,
      expectedFinishReason: 'other',
    },
  ];

  for (const test of testCases) {
    it(`should map Anthropic stop reason "${test.inputStopReason}" to Genkit finish reason "${test.expectedFinishReason}"`, () => {
      const actualOutput = testRunner.fromAnthropicStopReason(
        test.inputStopReason
      );
      assert.strictEqual(actualOutput, test.expectedFinishReason);
    });
  }
});

describe('fromAnthropicResponse', () => {
  const testCases: {
    should: string;
    message: Message;
    expectedOutput: Omit<GenerateResponseData, 'custom'>;
  }[] = [
    {
      should: 'should work with text content',
      message: {
        id: 'abc123',
        model: 'whatever',
        type: 'message',
        role: 'assistant',
        stop_reason: 'max_tokens',
        stop_sequence: null,
        content: [
          {
            type: 'text',
            text: 'Tell a joke about dogs.',
            citations: null,
          },
        ],
        usage: createUsage({
          input_tokens: 10,
          output_tokens: 20,
          cache_creation_input_tokens: null,
          cache_read_input_tokens: null,
        }),
      },
      expectedOutput: {
        candidates: [
          {
            index: 0,
            finishReason: 'length',
            message: {
              role: 'model',
              content: [{ text: 'Tell a joke about dogs.' }],
            },
          },
        ],
        usage: {
          inputTokens: 10,
          outputTokens: 20,
        },
      },
    },
    {
      should: 'should work with tool use content',
      message: {
        id: 'abc123',
        model: 'whatever',
        type: 'message',
        role: 'assistant',
        stop_reason: 'tool_use',
        stop_sequence: null,
        content: [
          {
            type: 'tool_use',
            id: 'abc123',
            name: 'tellAJoke',
            input: { topic: 'dogs' },
          },
        ],
        usage: createUsage({
          input_tokens: 10,
          output_tokens: 20,
          cache_creation_input_tokens: null,
          cache_read_input_tokens: null,
        }),
      },
      expectedOutput: {
        candidates: [
          {
            index: 0,
            finishReason: 'stop',
            message: {
              role: 'model',
              content: [
                {
                  toolRequest: {
                    name: 'tellAJoke',
                    input: { topic: 'dogs' },
                    ref: 'abc123',
                  },
                },
              ],
            },
          },
        ],
        usage: {
          inputTokens: 10,
          outputTokens: 20,
        },
      },
    },
  ];

  for (const test of testCases) {
    it(test.should, () => {
      const actualOutput = testRunner.fromAnthropicResponse(test.message);
      // Check custom field exists and is the message
      assert.ok(actualOutput.custom);
      assert.strictEqual(actualOutput.custom, test.message);
      // Check the rest
      assert.deepStrictEqual(
        {
          candidates: actualOutput.candidates,
          usage: actualOutput.usage,
        },
        test.expectedOutput
      );
    });
  }
});

describe('toAnthropicRequestBody', () => {
  const testCases: {
    should: string;
    modelName: string;
    genkitRequest: GenerateRequest<typeof AnthropicConfigSchema>;
    expectedOutput: MessageCreateParams;
  }[] = [
    {
      should: '(claude-3-5-haiku) handles request with text messages',
      modelName: 'claude-3-5-haiku',
      genkitRequest: {
        messages: [
          { role: 'user', content: [{ text: 'Tell a joke about dogs.' }] },
        ],
        output: { format: 'text' },
        config: {
          metadata: {
            user_id: 'exampleUser123',
          },
        },
      },
      expectedOutput: {
        max_tokens: 4096,
        messages: [
          {
            content: [
              {
                text: 'Tell a joke about dogs.',
                type: 'text',
                citations: null,
              },
            ],
            role: 'user',
          },
        ],
        model: 'claude-3-5-haiku',
        metadata: {
          user_id: 'exampleUser123',
        },
      },
    },
    {
      should: '(claude-3-haiku) handles request with text messages',
      modelName: 'claude-3-haiku',
      genkitRequest: {
        messages: [
          { role: 'user', content: [{ text: 'Tell a joke about dogs.' }] },
        ],
        output: { format: 'text' },
        config: {
          metadata: {
            user_id: 'exampleUser123',
          },
        },
      },
      expectedOutput: {
        max_tokens: 4096,
        messages: [
          {
            content: [
              {
                text: 'Tell a joke about dogs.',
                type: 'text',
                citations: null,
              },
            ],
            role: 'user',
          },
        ],
        model: 'claude-3-haiku',
        metadata: {
          user_id: 'exampleUser123',
        },
      },
    },
  ];
  for (const test of testCases) {
    it(test.should, () => {
      const actualOutput = testRunner.toAnthropicRequestBody(
        test.modelName,
        test.genkitRequest
      );
      assert.deepStrictEqual(actualOutput, test.expectedOutput);
    });
  }

  it('should accept any model name and use it directly', () => {
    // Following Google GenAI pattern: accept any model name, let API validate
    const result = testRunner.toAnthropicRequestBody('fake-model', {
      messages: [],
    } as GenerateRequest<typeof AnthropicConfigSchema>);

    // Should not throw, and should use the model name directly
    assert.strictEqual(result.model, 'fake-model');
  });

  it('should throw if output format is not text', () => {
    assert.throws(
      () =>
        testRunner.toAnthropicRequestBody('claude-3-5-haiku', {
          messages: [],
          tools: [],
          output: { format: 'media' },
        } as GenerateRequest<typeof AnthropicConfigSchema>),
      /Only text output format is supported for Claude models currently/
    );
  });

  it('should apply system prompt caching when enabled', () => {
    const request: GenerateRequest<typeof AnthropicConfigSchema> = {
      messages: [
        { role: 'system', content: [{ text: 'You are a helpful assistant' }] },
        { role: 'user', content: [{ text: 'Hi' }] },
      ],
      output: { format: 'text' },
    };

    // Test with caching enabled
    const outputWithCaching = testRunner.toAnthropicRequestBody(
      'claude-3-5-haiku',
      request,
      true
    );
    assert.deepStrictEqual(outputWithCaching.system, [
      {
        type: 'text',
        text: 'You are a helpful assistant',
        cache_control: { type: 'ephemeral' },
      },
    ]);

    // Test with caching disabled
    const outputWithoutCaching = testRunner.toAnthropicRequestBody(
      'claude-3-5-haiku',
      request,
      false
    );
    assert.strictEqual(
      outputWithoutCaching.system,
      'You are a helpful assistant'
    );
  });

  it('should concatenate multiple text parts in system message', () => {
    const request: GenerateRequest<typeof AnthropicConfigSchema> = {
      messages: [
        {
          role: 'system',
          content: [
            { text: 'You are a helpful assistant.' },
            { text: 'Always be concise.' },
            { text: 'Use proper grammar.' },
          ],
        },
        { role: 'user', content: [{ text: 'Hi' }] },
      ],
      output: { format: 'text' },
    };

    const output = testRunner.toAnthropicRequestBody(
      'claude-3-5-haiku',
      request,
      false
    );

    assert.strictEqual(
      output.system,
      'You are a helpful assistant.\n\nAlways be concise.\n\nUse proper grammar.'
    );
  });

  it('should concatenate multiple text parts in system message with caching', () => {
    const request: GenerateRequest<typeof AnthropicConfigSchema> = {
      messages: [
        {
          role: 'system',
          content: [
            { text: 'You are a helpful assistant.' },
            { text: 'Always be concise.' },
          ],
        },
        { role: 'user', content: [{ text: 'Hi' }] },
      ],
      output: { format: 'text' },
    };

    const output = testRunner.toAnthropicRequestBody(
      'claude-3-5-haiku',
      request,
      true
    );

    assert.deepStrictEqual(output.system, [
      {
        type: 'text',
        text: 'You are a helpful assistant.\n\nAlways be concise.',
        cache_control: { type: 'ephemeral' },
      },
    ]);
  });

  it('should throw error if system message contains media', () => {
    const request: GenerateRequest<typeof AnthropicConfigSchema> = {
      messages: [
        {
          role: 'system',
          content: [
            { text: 'You are a helpful assistant.' },
            {
              media: {
                url: '',
                contentType: 'image/png',
              },
            },
          ],
        },
        { role: 'user', content: [{ text: 'Hi' }] },
      ],
      output: { format: 'text' },
    };

    assert.throws(
      () =>
        testRunner.toAnthropicRequestBody('claude-3-5-haiku', request, false),
      /System messages can only contain text content/
    );
  });

  it('should throw error if system message contains tool requests', () => {
    const request: GenerateRequest<typeof AnthropicConfigSchema> = {
      messages: [
        {
          role: 'system',
          content: [
            { text: 'You are a helpful assistant.' },
            { toolRequest: { name: 'getTool', input: {}, ref: '123' } },
          ],
        },
        { role: 'user', content: [{ text: 'Hi' }] },
      ],
      output: { format: 'text' },
    };

    assert.throws(
      () =>
        testRunner.toAnthropicRequestBody('claude-3-5-haiku', request, false),
      /System messages can only contain text content/
    );
  });

  it('should throw error if system message contains tool responses', () => {
    const request: GenerateRequest<typeof AnthropicConfigSchema> = {
      messages: [
        {
          role: 'system',
          content: [
            { text: 'You are a helpful assistant.' },
            { toolResponse: { name: 'getTool', output: {}, ref: '123' } },
          ],
        },
        { role: 'user', content: [{ text: 'Hi' }] },
      ],
      output: { format: 'text' },
    };

    assert.throws(
      () =>
        testRunner.toAnthropicRequestBody('claude-3-5-haiku', request, false),
      /System messages can only contain text content/
    );
  });
});

describe('toAnthropicStreamingRequestBody', () => {
  it('should set stream to true', () => {
    const request: GenerateRequest<typeof AnthropicConfigSchema> = {
      messages: [{ role: 'user', content: [{ text: 'Hello' }] }],
      output: { format: 'text' },
    };

    const output = testRunner.toAnthropicStreamingRequestBody(
      'claude-3-5-haiku',
      request
    );

    assert.strictEqual(output.stream, true);
    assert.strictEqual(output.model, 'claude-3-5-haiku');
    assert.strictEqual(output.max_tokens, 4096);
  });

  it('should support system prompt caching in streaming mode', () => {
    const request: GenerateRequest<typeof AnthropicConfigSchema> = {
      messages: [
        { role: 'system', content: [{ text: 'You are a helpful assistant' }] },
        { role: 'user', content: [{ text: 'Hello' }] },
      ],
      output: { format: 'text' },
    };

    const outputWithCaching = testRunner.toAnthropicStreamingRequestBody(
      'claude-3-5-haiku',
      request,
      true
    );
    assert.deepStrictEqual(outputWithCaching.system, [
      {
        type: 'text',
        text: 'You are a helpful assistant',
        cache_control: { type: 'ephemeral' },
      },
    ]);
    assert.strictEqual(outputWithCaching.stream, true);

    const outputWithoutCaching = testRunner.toAnthropicStreamingRequestBody(
      'claude-3-5-haiku',
      request,
      false
    );
    assert.strictEqual(
      outputWithoutCaching.system,
      'You are a helpful assistant'
    );
    assert.strictEqual(outputWithoutCaching.stream, true);
  });
});

describe('claudeRunner', () => {
  it('should correctly run non-streaming requests', async () => {
    const mockClient = createMockAnthropicClient({
      messageResponse: {
        content: [{ type: 'text', text: 'response', citations: null }],
        usage: createUsage({
          input_tokens: 10,
          output_tokens: 20,
          cache_creation_input_tokens: 0,
          cache_read_input_tokens: 0,
        }),
      },
    });

    const runner = claudeRunner(
      {
        name: 'claude-3-5-haiku',
        client: mockClient,
      },
      AnthropicConfigSchema
    );
    const abortSignal = new AbortController().signal;
    await runner(
      { messages: [] },
      { streamingRequested: false, sendChunk: () => {}, abortSignal }
    );

    const createStub = mockClient.messages.create as any;
    assert.strictEqual(createStub.mock.calls.length, 1);
    assert.deepStrictEqual(createStub.mock.calls[0].arguments, [
      {
        model: 'claude-3-5-haiku',
        max_tokens: 4096,
        messages: [],
      },
      {
        signal: abortSignal,
      },
    ]);
  });

  it('should correctly run streaming requests', async () => {
    const mockClient = createMockAnthropicClient({
      streamChunks: [
        {
          type: 'content_block_start',
          index: 0,
          content_block: {
            type: 'text',
            text: 'res',
          },
        } as MessageStreamEvent,
      ],
      messageResponse: {
        content: [{ type: 'text', text: 'response', citations: null }],
        usage: createUsage({
          input_tokens: 10,
          output_tokens: 20,
          cache_creation_input_tokens: 0,
          cache_read_input_tokens: 0,
        }),
      },
    });

    const streamingCallback = mock.fn();
    const runner = claudeRunner(
      {
        name: 'claude-3-5-haiku',
        client: mockClient,
      },
      AnthropicConfigSchema
    );
    const abortSignal = new AbortController().signal;
    await runner(
      { messages: [] },
      { streamingRequested: true, sendChunk: streamingCallback, abortSignal }
    );

    const streamStub = mockClient.messages.stream as any;
    assert.strictEqual(streamStub.mock.calls.length, 1);
    assert.deepStrictEqual(streamStub.mock.calls[0].arguments, [
      {
        model: 'claude-3-5-haiku',
        max_tokens: 4096,
        messages: [],
        stream: true,
      },
      {
        signal: abortSignal,
      },
    ]);
  });

  it('should use beta API when apiVersion is beta', async () => {
    const mockClient = createMockAnthropicClient({
      messageResponse: {
        content: [{ type: 'text', text: 'response', citations: null }],
        usage: createUsage({
          input_tokens: 10,
          output_tokens: 20,
          cache_creation_input_tokens: 0,
          cache_read_input_tokens: 0,
        }),
      },
    });

    const runner = claudeRunner(
      {
        name: 'claude-3-5-haiku',
        client: mockClient,
      },
      AnthropicConfigSchema
    );
    const abortSignal = new AbortController().signal;
    await runner(
      {
        messages: [],
        config: { apiVersion: 'beta' },
      },
      { streamingRequested: false, sendChunk: () => {}, abortSignal }
    );

    const betaCreateStub = mockClient.beta.messages.create as any;
    assert.strictEqual(betaCreateStub.mock.calls.length, 1);

    const regularCreateStub = mockClient.messages.create as any;
    assert.strictEqual(regularCreateStub.mock.calls.length, 0);
  });

  it('should use beta API when defaultApiVersion is beta', async () => {
    const mockClient = createMockAnthropicClient({
      messageResponse: {
        content: [{ type: 'text', text: 'response', citations: null }],
        usage: createUsage({
          input_tokens: 10,
          output_tokens: 20,
          cache_creation_input_tokens: 0,
          cache_read_input_tokens: 0,
        }),
      },
    });

    const runner = claudeRunner(
      {
        name: 'claude-3-5-haiku',
        client: mockClient,
        defaultApiVersion: 'beta',
      },
      AnthropicConfigSchema
    );
    const abortSignal = new AbortController().signal;
    await runner(
      {
        messages: [],
      },
      { streamingRequested: false, sendChunk: () => {}, abortSignal }
    );

    const betaCreateStub = mockClient.beta.messages.create as any;
    assert.strictEqual(betaCreateStub.mock.calls.length, 1);

    const regularCreateStub = mockClient.messages.create as any;
    assert.strictEqual(regularCreateStub.mock.calls.length, 0);
  });

  it('should use request apiVersion over defaultApiVersion', async () => {
    const mockClient = createMockAnthropicClient({
      messageResponse: {
        content: [{ type: 'text', text: 'response', citations: null }],
        usage: createUsage({
          input_tokens: 10,
          output_tokens: 20,
          cache_creation_input_tokens: 0,
          cache_read_input_tokens: 0,
        }),
      },
    });

    // defaultApiVersion is 'stable', but request overrides to 'beta'
    const runner = claudeRunner(
      {
        name: 'claude-3-5-haiku',
        client: mockClient,
        defaultApiVersion: 'stable',
      },
      AnthropicConfigSchema
    );
    const abortSignal = new AbortController().signal;
    await runner(
      {
        messages: [],
        config: { apiVersion: 'beta' },
      },
      { streamingRequested: false, sendChunk: () => {}, abortSignal }
    );

    const betaCreateStub = mockClient.beta.messages.create as any;
    assert.strictEqual(betaCreateStub.mock.calls.length, 1);

    const regularCreateStub = mockClient.messages.create as any;
    assert.strictEqual(regularCreateStub.mock.calls.length, 0);
  });

  it('should use stable API when defaultApiVersion is beta but request overrides to stable', async () => {
    const mockClient = createMockAnthropicClient({
      messageResponse: {
        content: [{ type: 'text', text: 'response', citations: null }],
        usage: createUsage({
          input_tokens: 10,
          output_tokens: 20,
          cache_creation_input_tokens: 0,
          cache_read_input_tokens: 0,
        }),
      },
    });

    // defaultApiVersion is 'beta', but request overrides to 'stable'
    const runner = claudeRunner(
      {
        name: 'claude-3-5-haiku',
        client: mockClient,
        defaultApiVersion: 'beta',
      },
      AnthropicConfigSchema
    );
    const abortSignal = new AbortController().signal;
    await runner(
      {
        messages: [],
        config: { apiVersion: 'stable' },
      },
      { streamingRequested: false, sendChunk: () => {}, abortSignal }
    );

    const betaCreateStub = mockClient.beta.messages.create as any;
    assert.strictEqual(betaCreateStub.mock.calls.length, 0);

    const regularCreateStub = mockClient.messages.create as any;
    assert.strictEqual(regularCreateStub.mock.calls.length, 1);
  });
});

describe('claudeRunner param object', () => {
  it('should run requests when constructed with params object', async () => {
    const mockClient = createMockAnthropicClient();
    const runner = claudeRunner(
      {
        name: 'claude-3-5-haiku',
        client: mockClient,
        cacheSystemPrompt: true,
      },
      AnthropicConfigSchema
    );
    const abortSignal = new AbortController().signal;

    await runner(
      { messages: [{ role: 'user', content: [{ text: 'hi' }] }] },
      { streamingRequested: false, sendChunk: () => {}, abortSignal }
    );

    const createStub = mockClient.messages.create as any;
    assert.strictEqual(createStub.mock.calls.length, 1);
    assert.strictEqual(
      createStub.mock.calls[0].arguments[0].messages[0].content[0].text,
      'hi'
    );
  });

  it('should route to beta runner when defaultApiVersion is beta', async () => {
    const mockClient = createMockAnthropicClient();
    const runner = claudeRunner(
      {
        name: 'claude-3-5-haiku',
        client: mockClient,
        defaultApiVersion: 'beta',
      },
      AnthropicConfigSchema
    );
    await runner(
      { messages: [] },
      {
        streamingRequested: false,
        sendChunk: () => {},
        abortSignal: new AbortController().signal,
      }
    );

    const betaCreateStub = mockClient.beta.messages.create as any;
    assert.strictEqual(betaCreateStub.mock.calls.length, 1);
  });

  it('should throw when client is omitted from params object', () => {
    assert.throws(() => {
      claudeRunner(
        {
          name: 'claude-3-5-haiku',
          client: undefined as unknown as Anthropic,
        },
        AnthropicConfigSchema
      );
    }, /Anthropic client is required to create a runner/);
  });
});

describe('claudeModel', () => {
  it('should fall back to generic metadata for unknown models', async () => {
    const mockClient = createMockAnthropicClient();
    const modelAction = claudeModel({
      name: 'unknown-model',
      client: mockClient,
    });

    const abortSignal = new AbortController().signal;
    await (modelAction as any)(
      { messages: [{ role: 'user', content: [{ text: 'hi' }] }] },
      {
        streamingRequested: false,
        sendChunk: () => {},
        abortSignal,
      }
    );

    const createStub = mockClient.messages.create as any;
    assert.strictEqual(createStub.mock.calls.length, 1);
    const request = createStub.mock.calls[0].arguments[0];
    assert.strictEqual(request.model, 'unknown-model');
  });
  it('should support params object configuration', async () => {
    const mockClient = createMockAnthropicClient();
    const modelAction = claudeModel({
      name: 'claude-3-5-haiku',
      client: mockClient,
      defaultApiVersion: 'beta',
      cacheSystemPrompt: true,
    });

    const abortSignal = new AbortController().signal;
    await (modelAction as any)(
      { messages: [], config: { maxOutputTokens: 128 } },
      {
        streamingRequested: false,
        sendChunk: () => {},
        abortSignal,
      }
    );

    const betaCreateStub = mockClient.beta.messages.create as any;
    assert.strictEqual(betaCreateStub.mock.calls.length, 1);
    assert.strictEqual(
      betaCreateStub.mock.calls[0].arguments[0].max_tokens,
      128
    );
  });

  it('should correctly define supported Claude models', () => {
    const mockClient = createMockAnthropicClient();
    const modelName = 'claude-3-5-haiku';
    const modelAction = claudeModel({
      name: modelName,
      client: mockClient,
    });

    // Verify the model action is returned
    assert.ok(modelAction);
    assert.strictEqual(typeof modelAction, 'function');
  });

  it('should accept any model name and create a model action', () => {
    // Following Google GenAI pattern: accept any model name, let API validate
    const modelAction = claudeModel({
      name: 'unsupported-model',
      client: {} as Anthropic,
    });
    assert.ok(modelAction, 'Should create model action for any model name');
    assert.strictEqual(typeof modelAction, 'function');
  });

  it('should handle streaming with multiple text chunks', async () => {
    const mockClient = createMockAnthropicClient({
      streamChunks: [
        mockContentBlockStart('Hello'),
        mockTextChunk(' world'),
        mockTextChunk('!'),
      ],
      messageResponse: {
        content: [{ type: 'text', text: 'Hello world!', citations: null }],
        usage: createUsage({
          input_tokens: 5,
          output_tokens: 10,
          cache_creation_input_tokens: 0,
          cache_read_input_tokens: 0,
        }),
      },
    });

    const chunks: any[] = [];
    const streamingCallback = mock.fn((chunk: any) => {
      chunks.push(chunk);
    });

    const runner = claudeRunner(
      {
        name: 'claude-3-5-haiku',
        client: mockClient,
      },
      AnthropicConfigSchema
    );
    const abortSignal = new AbortController().signal;

    const result = await runner(
      { messages: [{ role: 'user', content: [{ text: 'Hi' }] }] },
      { streamingRequested: true, sendChunk: streamingCallback, abortSignal }
    );

    // Verify we received all the streaming chunks
    assert.ok(chunks.length > 0, 'Should have received streaming chunks');
    assert.strictEqual(chunks.length, 3, 'Should have received 3 chunks');

    // Verify the final result
    assert.ok(result.candidates);
    assert.strictEqual(
      result.candidates[0].message.content[0].text,
      'Hello world!'
    );
    assert.ok(result.usage);
    assert.strictEqual(result.usage.inputTokens, 5);
    assert.strictEqual(result.usage.outputTokens, 10);
  });

  it('should handle tool use in streaming mode', async () => {
    const streamChunks = [
      {
        type: 'content_block_start',
        index: 0,
        content_block: {
          type: 'tool_use',
          id: 'toolu_123',
          name: 'get_weather',
          input: { city: 'NYC' },
        },
      } as MessageStreamEvent,
    ];
    const mockClient = createMockAnthropicClient({
      streamChunks,
      messageResponse: {
        content: [
          {
            type: 'tool_use',
            id: 'toolu_123',
            name: 'get_weather',
            input: { city: 'NYC' },
          },
        ],
        stop_reason: 'tool_use',
        usage: createUsage({
          input_tokens: 15,
          output_tokens: 25,
          cache_creation_input_tokens: 0,
          cache_read_input_tokens: 0,
        }),
      },
    });

    const chunks: any[] = [];
    const streamingCallback = mock.fn((chunk: any) => {
      chunks.push(chunk);
    });

    const runner = claudeRunner(
      {
        name: 'claude-3-5-haiku',
        client: mockClient,
      },
      AnthropicConfigSchema
    );
    const abortSignal = new AbortController().signal;

    const result = await runner(
      {
        messages: [
          { role: 'user', content: [{ text: 'What is the weather?' }] },
        ],
        tools: [
          {
            name: 'get_weather',
            description: 'Get the weather for a city',
            inputSchema: {
              type: 'object',
              properties: {
                city: { type: 'string' },
              },
              required: ['city'],
            },
          },
        ],
      },
      { streamingRequested: true, sendChunk: streamingCallback, abortSignal }
    );

    // Verify we received the tool use chunk
    assert.ok(chunks.length > 0, 'Should have received chunks');

    // Verify the final result contains tool use
    assert.ok(result.candidates);
    const toolRequest = result.candidates[0].message.content.find(
      (p) => p.toolRequest
    );
    assert.ok(toolRequest, 'Should have a tool request');
    assert.strictEqual(toolRequest.toolRequest?.name, 'get_weather');
    assert.deepStrictEqual(toolRequest.toolRequest?.input, { city: 'NYC' });
  });

  it('should handle streaming errors and partial responses', async () => {
    const streamError = new Error('Network error during streaming');
    const mockClient = createMockAnthropicClient({
      streamChunks: [mockContentBlockStart('Hello'), mockTextChunk(' world')],
      streamErrorAfterChunk: 1, // Throw error after first chunk
      streamError: streamError,
      messageResponse: {
        content: [{ type: 'text', text: 'Hello world', citations: null }],
        usage: createUsage({
          input_tokens: 5,
          output_tokens: 10,
          cache_creation_input_tokens: 0,
          cache_read_input_tokens: 0,
        }),
      },
    });

    const runner = claudeRunner(
      {
        name: 'claude-3-5-haiku',
        client: mockClient,
      },
      AnthropicConfigSchema
    );
    const abortSignal = new AbortController().signal;
    const chunks: any[] = [];
    const sendChunk = (chunk: any) => {
      chunks.push(chunk);
    };

    // Should throw error during streaming
    await assert.rejects(
      async () => {
        await runner(
          { messages: [{ role: 'user', content: [{ text: 'Hi' }] }] },
          {
            streamingRequested: true,
            sendChunk,
            abortSignal,
          }
        );
      },
      (error: Error) => {
        // Verify error is propagated
        assert.strictEqual(error.message, 'Network error during streaming');
        // Verify we received at least one chunk before error
        assert.ok(
          chunks.length > 0,
          'Should have received some chunks before error'
        );
        return true;
      }
    );
  });

  it('should handle abort signal during streaming', async () => {
    const mockClient = createMockAnthropicClient({
      streamChunks: [
        mockContentBlockStart('Hello'),
        mockTextChunk(' world'),
        mockTextChunk('!'),
      ],
      messageResponse: {
        content: [{ type: 'text', text: 'Hello world!', citations: null }],
        usage: createUsage({
          input_tokens: 5,
          output_tokens: 15,
          cache_creation_input_tokens: 0,
          cache_read_input_tokens: 0,
        }),
      },
    });

    const runner = claudeRunner(
      {
        name: 'claude-3-5-haiku',
        client: mockClient,
      },
      AnthropicConfigSchema
    );
    const abortController = new AbortController();
    const chunks: any[] = [];
    const sendChunk = (chunk: any) => {
      chunks.push(chunk);
      // Abort after first chunk
      if (chunks.length === 1) {
        abortController.abort();
      }
    };

    // Should throw AbortError when signal is aborted
    await assert.rejects(
      async () => {
        await runner(
          { messages: [{ role: 'user', content: [{ text: 'Hi' }] }] },
          {
            streamingRequested: true,
            sendChunk,
            abortSignal: abortController.signal,
          }
        );
      },
      (error: Error) => {
        // Verify abort error is thrown
        assert.ok(
          error.name === 'AbortError' || error.message.includes('AbortError'),
          'Should throw AbortError'
        );
        return true;
      }
    );
  });

  it('should handle unknown models using generic settings', async () => {
    const mockClient = createMockAnthropicClient();
    const modelAction = claudeModel({
      name: 'unknown-model',
      client: mockClient,
    });

    const abortSignal = new AbortController().signal;
    await (modelAction as any)(
      { messages: [{ role: 'user', content: [{ text: 'hi' }] }] },
      {
        streamingRequested: false,
        sendChunk: () => {},
        abortSignal,
      }
    );

    const createStub = mockClient.messages.create as any;
    assert.strictEqual(createStub.mock.calls.length, 1);
    assert.strictEqual(
      createStub.mock.calls[0].arguments[0].model,
      'unknown-model'
    );
  });
});

describe('BaseRunner helper utilities', () => {
  it('should throw descriptive errors for invalid PDF data URLs', () => {
    const mockClient = createMockAnthropicClient();
    const runner = new Runner({
      name: 'claude-3-5-haiku',
      client: mockClient,
    });

    assert.throws(
      () =>
        runner['toPdfDocumentSource']({
          url: 'data:text/plain;base64,AAA',
          contentType: 'application/pdf',
        } as any),
      /PDF contentType mismatch/
    );
  });

  it('should stringify non-media tool responses', () => {
    const mockClient = createMockAnthropicClient();
    const runner = new Runner({
      name: 'claude-3-5-haiku',
      client: mockClient,
    });

    const result = runner['toAnthropicToolResponseContent']({
      toolResponse: {
        ref: 'call_1',
        name: 'tool',
        output: { value: 42 },
      },
    } as any);

    assert.deepStrictEqual(result, {
      type: 'text',
      text: JSON.stringify({ value: 42 }),
    });
  });

  it('should parse image data URLs', () => {
    const mockClient = createMockAnthropicClient();
    const runner = new Runner({
      name: 'claude-3-5-haiku',
      client: mockClient,
    });

    const source = runner['toImageSource']({
      url: '',
      contentType: 'image/png',
    });

    assert.strictEqual(source.kind, 'base64');
    if (source.kind !== 'base64') {
      throw new Error('Expected base64 image source');
    }
    assert.strictEqual(source.mediaType, 'image/png');
    assert.strictEqual(source.data, 'AAA');
  });

  it('should pass through remote image URLs', () => {
    const mockClient = createMockAnthropicClient();
    const runner = new Runner({
      name: 'claude-3-5-haiku',
      client: mockClient,
    });

    const source = runner['toImageSource']({
      url: 'https://example.com/image.png',
      contentType: 'image/png',
    });

    assert.strictEqual(source.kind, 'url');
    if (source.kind !== 'url') {
      throw new Error('Expected url image source');
    }
    assert.strictEqual(source.url, 'https://example.com/image.png');
  });

  it('should parse WEBP image data URLs with matching contentType', () => {
    const mockClient = createMockAnthropicClient();
    const runner = new Runner({
      name: 'claude-3-5-haiku',
      client: mockClient,
    });

    const source = runner['toImageSource']({
      url: '',
      contentType: 'image/webp',
    });

    assert.strictEqual(source.kind, 'base64');
    if (source.kind !== 'base64') {
      throw new Error('Expected base64 image source');
    }
    assert.strictEqual(source.mediaType, 'image/webp');
    assert.strictEqual(source.data, 'AAA');
  });

  it('should prefer data URL content type over media.contentType for WEBP', () => {
    const mockClient = createMockAnthropicClient();
    const runner = new Runner({
      name: 'claude-3-5-haiku',
      client: mockClient,
    });

    // Even if contentType says PNG, data URL says WEBP - should use WEBP
    const source = runner['toImageSource']({
      url: '',
      contentType: 'image/png',
    });

    assert.strictEqual(source.kind, 'base64');
    if (source.kind !== 'base64') {
      throw new Error('Expected base64 image source');
    }
    // Key fix: should use data URL type (webp), not contentType (png)
    assert.strictEqual(source.mediaType, 'image/webp');
    assert.strictEqual(source.data, 'AAA');
  });

  it('should handle WEBP via toAnthropicMessageContent', () => {
    const result = testRunner.toAnthropicMessageContent({
      media: {
        url: '',
        contentType: 'image/webp',
      },
    });

    assert.strictEqual(result.type, 'image');
    assert.strictEqual(result.source.type, 'base64');
    assert.strictEqual(result.source.media_type, 'image/webp');
    assert.strictEqual(result.source.data, 'AAA');
  });

  it('should handle WEBP in tool response content', () => {
    const mockClient = createMockAnthropicClient();
    const runner = new Runner({
      name: 'claude-3-5-haiku',
      client: mockClient,
    });

    const result = runner['toAnthropicToolResponseContent']({
      toolResponse: {
        ref: 'call_123',
        name: 'get_image',
        output: {
          url: '',
          contentType: 'image/webp',
        },
      },
    } as any);

    assert.strictEqual(result.type, 'image');
    assert.strictEqual(result.source.type, 'base64');
    assert.strictEqual(result.source.media_type, 'image/webp');
    assert.strictEqual(result.source.data, 'AAA');
  });

  it('should throw helpful error for text/plain in toImageSource', () => {
    const mockClient = createMockAnthropicClient();
    const runner = new Runner({
      name: 'claude-3-5-haiku',
      client: mockClient,
    });

    assert.throws(
      () =>
        runner['toImageSource']({
          url: 'data:text/plain;base64,AAA',
          contentType: 'text/plain',
        }),
      (error: Error) => {
        return (
          error.message.includes('Text files should be sent as text content') &&
          error.message.includes('text:')
        );
      }
    );
  });

  it('should throw helpful error for text/plain in toAnthropicMessageContent', () => {
    assert.throws(
      () =>
        testRunner.toAnthropicMessageContent({
          media: {
            url: 'data:text/plain;base64,AAA',
            contentType: 'text/plain',
          },
        }),
      (error: Error) => {
        return (
          error.message.includes('Text files should be sent as text content') &&
          error.message.includes('text:')
        );
      }
    );
  });

  it('should throw helpful error for text/plain in tool response', () => {
    const mockClient = createMockAnthropicClient();
    const runner = new Runner({
      name: 'claude-3-5-haiku',
      client: mockClient,
    });

    assert.throws(
      () =>
        runner['toAnthropicToolResponseContent']({
          toolResponse: {
            ref: 'call_123',
            name: 'get_file',
            output: {
              url: 'data:text/plain;base64,AAA',
              contentType: 'text/plain',
            },
          },
        } as any),
      (error: Error) => {
        return error.message.includes(
          'Text files should be sent as text content'
        );
      }
    );
  });

  it('should throw helpful error for text/plain with remote URL', () => {
    const mockClient = createMockAnthropicClient();
    const runner = new Runner({
      name: 'claude-3-5-haiku',
      client: mockClient,
    });

    assert.throws(
      () =>
        runner['toImageSource']({
          url: 'https://example.com/file.txt',
          contentType: 'text/plain',
        }),
      (error: Error) => {
        return (
          error.message.includes('Text files should be sent as text content') &&
          error.message.includes('text:')
        );
      }
    );
  });
});

describe('Runner request bodies and error branches', () => {
  it('should include optional config fields in non-streaming request body', () => {
    const mockClient = createMockAnthropicClient();
    const runner = new Runner({
      name: 'claude-3-5-haiku',
      client: mockClient,
      cacheSystemPrompt: true,
    }) as Runner & RunnerProtectedMethods;

    const body = runner['toAnthropicRequestBody'](
      'claude-3-5-haiku',
      {
        messages: [
          {
            role: 'system',
            content: [{ text: 'You are helpful.' }],
          },
          {
            role: 'user',
            content: [{ text: 'Tell me a joke' }],
          },
        ],
        config: {
          maxOutputTokens: 256,
          topK: 3,
          topP: 0.75,
          temperature: 0.6,
          stopSequences: ['END'],
          metadata: { user_id: 'user-xyz' },
          tool_choice: { type: 'auto' },
          thinking: { enabled: true, budgetTokens: 2048 },
        },
        tools: [
          {
            name: 'get_weather',
            description: 'Returns the weather',
            inputSchema: { type: 'object' },
          },
        ],
      } as unknown as GenerateRequest<typeof AnthropicConfigSchema>,
      true
    );

    assert.strictEqual(body.model, 'claude-3-5-haiku');
    assert.ok(Array.isArray(body.system));
    assert.strictEqual(body.system?.[0].cache_control?.type, 'ephemeral');
    assert.strictEqual(body.max_tokens, 256);
    assert.strictEqual(body.top_k, 3);
    assert.strictEqual(body.top_p, 0.75);
    assert.strictEqual(body.temperature, 0.6);
    assert.deepStrictEqual(body.stop_sequences, ['END']);
    assert.deepStrictEqual(body.metadata, { user_id: 'user-xyz' });
    assert.deepStrictEqual(body.tool_choice, { type: 'auto' });
    assert.strictEqual(body.tools?.length, 1);
    assert.deepStrictEqual(body.thinking, {
      type: 'enabled',
      budget_tokens: 2048,
    });
  });

  it('should include optional config fields in streaming request body', () => {
    const mockClient = createMockAnthropicClient();
    const runner = new Runner({
      name: 'claude-3-5-haiku',
      client: mockClient,
      cacheSystemPrompt: true,
    }) as Runner & RunnerProtectedMethods;

    const body = runner['toAnthropicStreamingRequestBody'](
      'claude-3-5-haiku',
      {
        messages: [
          {
            role: 'system',
            content: [{ text: 'Stay brief.' }],
          },
          {
            role: 'user',
            content: [{ text: 'Summarize the weather.' }],
          },
        ],
        config: {
          maxOutputTokens: 64,
          topK: 2,
          topP: 0.6,
          temperature: 0.4,
          stopSequences: ['STOP'],
          metadata: { user_id: 'user-abc' },
          tool_choice: { type: 'any' },
          thinking: { enabled: true, budgetTokens: 1536 },
        },
        tools: [
          {
            name: 'summarize_weather',
            description: 'Summarizes a forecast',
            inputSchema: { type: 'object' },
          },
        ],
      } as unknown as GenerateRequest<typeof AnthropicConfigSchema>,
      true
    );

    assert.strictEqual(body.stream, true);
    assert.ok(Array.isArray(body.system));
    assert.strictEqual(body.max_tokens, 64);
    assert.strictEqual(body.top_k, 2);
    assert.strictEqual(body.top_p, 0.6);
    assert.strictEqual(body.temperature, 0.4);
    assert.deepStrictEqual(body.stop_sequences, ['STOP']);
    assert.deepStrictEqual(body.metadata, { user_id: 'user-abc' });
    assert.deepStrictEqual(body.tool_choice, { type: 'any' });
    assert.strictEqual(body.tools?.length, 1);
    assert.deepStrictEqual(body.thinking, {
      type: 'enabled',
      budget_tokens: 1536,
    });
  });

  it('should disable thinking when explicitly turned off', () => {
    const mockClient = createMockAnthropicClient();
    const runner = new Runner({
      name: 'claude-3-5-haiku',
      client: mockClient,
    }) as Runner & RunnerProtectedMethods;

    const body = runner['toAnthropicRequestBody'](
      'claude-3-5-haiku',
      {
        messages: [],
        config: {
          thinking: { enabled: false },
        },
      } as unknown as GenerateRequest<typeof AnthropicConfigSchema>,
      false
    );

    assert.deepStrictEqual(body.thinking, { type: 'disabled' });
  });

  it('should throw descriptive errors for missing tool refs', () => {
    const mockClient = createMockAnthropicClient();
    const runner = new Runner({
      name: 'claude-3-5-haiku',
      client: mockClient,
      cacheSystemPrompt: false,
    }) as Runner & RunnerProtectedMethods;

    assert.throws(
      () =>
        runner['toAnthropicMessageContent']({
          toolRequest: {
            name: 'get_weather',
            input: {},
          },
        } as any),
      /Tool request ref is required/
    );

    assert.throws(
      () =>
        runner['toAnthropicMessageContent']({
          toolResponse: {
            ref: undefined,
            name: 'get_weather',
            output: 'Sunny',
          },
        } as any),
      /Tool response ref is required/
    );

    assert.throws(
      () =>
        runner['toAnthropicMessageContent']({
          data: 'unexpected',
        } as any),
      /Unsupported genkit part fields/
    );
  });
});
